#include "tipo_string.h"

std::string TipoString::invalido = "";

TipoString::TipoString(const std::string &val):TipoDato(true){
	this->valor = val;
}
TipoString::TipoString():TipoDato(true){
	this->valor = TipoString::invalido;	
}

bool TipoString::esta_cargado() const{
	return (this->valor != TipoString::invalido);	
}
	
TipoDato& TipoString::operator= (const TipoDato& dato) throw (ExcepErrorTipos){
	if (this == &dato)
		return *this;
	if (!mismo_tipo(dato))
		throw ExcepErrorTipos("Error - Se esperaba tipo string");
	TipoString* aux = (TipoString*) &dato;
	this->valor = aux->valor;
	this->obligatorio = aux->obligatorio;
	return *this;
}

TipoString& TipoString::operator= (const std::string &valor){
	this->valor = valor;
	return *this;
}
	
std::string TipoString::get_valor(){
	return this->valor;
}
		
bool TipoString::operator== (const TipoDato& dato) const throw (ExcepErrorTipos){
	if (!mismo_tipo(dato))
		throw ExcepErrorTipos("Error - Se esperaba tipo string");
	TipoString* aux = (TipoString*) &dato;
	return (this->valor.compare(aux->valor) == 0);
}

bool TipoString::operator< (const TipoDato& dato) const throw (ExcepErrorTipos){
	if (!mismo_tipo(dato))
		throw ExcepErrorTipos("Error - Se esperaba tipo string");
	TipoString* aux = (TipoString*) &dato;
	return (this->valor < aux->valor);
}
	
CodTipo TipoString::get_codigo_tipo() const{
	return STRING;
}

TipoDato* TipoString::clonar() const{
	TipoString* aux = new TipoString(this->valor);
	return aux;
}

unsigned int TipoString::get_tamanio() const{
	return 0;	
}

ostream& TipoString::toStream(ostream& out) const {
	out << this->valor;
	return out;
}
void TipoString::serializar(char ** retorno, unsigned int &tam){
	unsigned short int cant_letras = this->valor.size();
	tam = sizeof(unsigned short int) + cant_letras;
	*retorno = new char[tam];
	
	//copio el tag del la cantidad de letras
	memcpy(*retorno, &cant_letras, sizeof(unsigned short int));
	memcpy((*retorno) + sizeof(unsigned short int), this->valor.c_str(), cant_letras);
}
		
bool TipoString::deserializar(char * serializados, unsigned int tam){
	if( tam > 2 ){
		//saco la cantidad de letras que tiene
		unsigned short int cant_letras;
		memcpy(&cant_letras, serializados, sizeof(unsigned short int) );
		//copio la cadena
		char * cad_leida = new char[cant_letras + 1];
		memcpy(cad_leida, serializados + sizeof(unsigned short int), cant_letras);
		cad_leida[cant_letras] = 0; 
		this->valor = cad_leida;
		delete[] cad_leida;
		return true;
	} 
	return false;
}
